﻿//#include <iostream>
//
//using namespace std;
//
//class Date
//{
//public:
//	//Date()
//	//{
//	//	_year = 1;
//	//	_month = 1;
//	//	_day = 1;
//	//}
//	Date(int year = 2025, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//typedef int STDataType;
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//class MyQueue
//{
//public:
//	// 其实就算我们写了但是什么写不干，编译器也会初始化，这时候要用到初始化列表
//	//MyQueue()
//	//{
//
//	//}
//	// /编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
//private:
//	Stack pushst;
//	Stack popst;
//};
//
//
//int main()
//{
//	// Date a() 不能这样写，无法和函数声明区分开
//	Date a;
//	a.print();
//	MyQueue q;
//	return 0;
//}



//#include <iostream>
//
//using namespace std;
//
//typedef int STDataType;
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//	~Stack()
//	{
//		free(_a);
//		_a = nullptr;
//		_capacity = _top = 0;
//	}
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//class MyQueue
//{
//public:
//	// 对于自定义类型不写会调用他的析构
//	// 如果写了也会调用自定义类型的析构
//	~MyQueue()
//	{
//
//	}
//private:
//	Stack pushst;
//	Stack popst;
//};
//
//
//int main()
//{
//	// Date a() 不能这样写，无法和函数声明区分开
//	MyQueue q;
//	return 0;
//}


//#include <iostream>
//
//using namespace std;
//
//class Date
//{
//public:
//	Date(int year = 2025, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	Date(const Date& d) // 拷贝构造函数
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	Date(Date* d)
//	{
//		_year = d->_year;
//		_month = d->_month;
//		_day = d->_day;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//
//};
////Date f(Date& d)
//Date f(Date d) // 传值传参调用拷贝构造
//{
//	return d; // 传值返回调用拷贝构造
//}
//
//
//typedef int STDataType;
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//	Stack(const Stack& st)
//	{
//		// 需要对_a指向资源创建同样⼤的资源再拷⻉值
//		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败!!!");
//			return;
//		}
//		memcpy(_a, st._a, sizeof(STDataType) * st._top);
//		_top = st._top;
//		_capacity = st._capacity;
//	}
//
//
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//class MyQueue
//{
//public:
//
//private:
//	Stack st1;
//	Stack st2;
//};
//int main()
//{
//	Date d1(2025, 5, 9);
//	Date d2(d1); // 拷贝构造
//
//	// 这⾥可以完成拷⻉，但是不是拷⻉构造，只是⼀个普通的构造
//	Date d3(&d1);
//	// 也可以这样写，这⾥也是拷⻉构造
//	Date d4 = d1;
//
//
//
//	Stack st1;
//
//	// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉
//	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
//	Stack st2 = st1;
//
//	MyQueue mq1;
//	// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst / popst
//	// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题
//	MyQueue mq2(mq1);
//	return 0;
//}

//#include <iostream>
//#include <vector>
//#include <cstring>
//using namespace std;
//typedef pair<int, int> PII;
//const int N = 5010, INF = 0x3f3f3f3f;
//int n, m;
//vector<PII> edges[N];
//int dist[N];
//bool st[N];
//int prim()
//{
//    memset(dist, 0x3f, sizeof dist);
//    dist[1] = 0;
//    int ret = 0;
//    for (int i = 1; i <= n; i++)
//    {
//        // 1. 找最近点
//
//        int t = 0;
//        for (int j = 1; j <= n; j++)
//            if (!st[j] && dist[j] < dist[t])
//                t = j;
//        // 判断是否联通
//
//        if (dist[t] == INF) return INF;
//        st[t] = true;
//        ret += dist[t];
//        // 2. 更新距离
//
//            for (auto& p : edges[t])
//            {
//                int a = p.first, b = p.second;
//                // t->a 权值b
//                dist[a] = min(dist[a], b);
//            }
//    }
//    return ret;
//}
//int main()
//{
//    cin >> n >> m;
//    for (int i = 1; i <= m; i++)
//    {
//        int x, y, z; cin >> x >> y >> z;
//        // 如果有重边，怎么办？
//
//        edges[x].push_back({ y, z });
//        edges[y].push_back({ x, z });
//    }
//    int ret = prim();
//    if (ret == INF) cout << "orz" << endl;
//    else cout << ret << endl;
//    return 0;
//}

//#include <iostream>
//using namespace std;
//typedef long long LL;
//#define endl '\n'
//int cnt[150];
//
//void solve()
//{
//	string s; cin >> s;
//	int l = -1, r = -1;
//	double maxa = 0;
//	int a = 0, b = 0;
//	int n = s.size();
//	//cout << (r < s.size()) << endl;
//	while (r < n - 1)
//	{
//		++r;
//		cnt[s[r]]++;
//		b++;
//		if (cnt[s[r]] == 1) a++;
//		else
//		{
//			while (cnt[s[l + 1]] > 1)
//			{
//				l++;
//				cnt[s[l]]--;
//				b--;
//			}
//		}
//	}
//	cout << a << " " << b << endl;
//}
//
//int main()
//{
//	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
//	int T = 1;
//	// cin >> T;
//	while (T--)
//	{
//		solve();
//	}
//	return 0;
//}

//#include <iostream>
//#include <unordered_map>
//using namespace std;
//typedef long long LL;
//#define endl '\n'
//int cntmax = 0;
//
//// bool check(int len, int cnt)
//// {
//// 	for(int i = 0; i + len - 1 < )
//// }
//
//void solve()
//{
//	string s; cin >> s;
//	int n = s.size();
//	unordered_map<char, int> mp;
//	for (auto ch : s)
//	{
//		if (mp.count(ch)) continue;
//		mp[ch]++;
//		cntmax++;
//	}
//	cout << cntmax << endl;
//	// for(int i = 1; i <= 26; i++)
//	// {
//	// 	int l = 1, r = n;
//	// 	while(l < r)
//	// 	{
//	// 		int mid = (l + r) >> 1;
//	// 		if(check(mid, i)) r = mid;
//	// 		else l = mid + 1;
//	// 	}
//	// }
//}
//
//int main()
//{
//	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
//	int T = 1;
//	// cin >> T;
//	while (T--)
//	{
//		solve();
//	}
//	return 0;
//}


//#include <iostream>
//#include <unordered_map>
//#include <algorithm>
//using namespace std;
//typedef long long LL;
//#define endl '\n'
//int cntmax = 0;
//int n;
//string s;
//
//LL gcd(LL a, LL b)
//{
//	return b == 0 ? a : gcd(b, a % b);
//}
//
//bool check(int len, int cnt)
//{
//	if (cnt > cntmax) return false;
//	int cntcur = 0;
//	unordered_map<char, int> mp;
//	for (int i = 0; i <= len - 1; i++)
//	{
//		if (mp.count(s[i])) continue;
//		mp[s[i]]++;
//		cntcur++;
//	}
//
//	for (int i = 0, j = len + i - 1; i + len - 1 < n; i++, j++)
//	{
//		if (cntcur >= cnt) return true;
//		if (j + 1 < n)
//		{
//			mp[s[i]]--;
//			if (mp[s[i]] == 0) cntcur--;
//			if (mp[s[j + 1]] == 0) cntcur++;
//			mp[s[j + 1]]++;
//		}
//	}
//	return false;
//}
//
//void solve()
//{
//	cin >> s;
//	n = s.size();
//	if (n == 1) 
//	{
//		cout << 1 << ' ' << 1 << endl;
//		return;
//	}
//
//	unordered_map<char, int> mp;
//	for (auto ch : s)
//	{
//		if (mp.count(ch)) continue;
//		mp[ch]++;
//		cntmax++;
//	}
//	int a = 0, b = 0;
//	vector<pair<int, int>> e;
//	for (int i = 1; i <= 26; i++)
//	{
//		int l = 1, r = n + 1;
//		while (l < r)
//		{
//			int mid = (l + r) >> 1;
//			if (check(mid, i))
//			{
//				r = mid;
//				e.push_back({ i * i, mid });
//			}
//			else l = mid + 1;
//		}
//	}
//	int ansa = 0, ansb = 0;
//	double tmp = 0;
//	for (auto& t : e)
//	{
//		int a = t.first, b = t.second;
//		//cout << a << " " << b << endl;
//		double c = a * 1.0 / b;
//		if (c > tmp)
//		{
//			tmp = c;
//			ansa = a;
//			ansb = b;
//		}
//	}
//	int p = gcd(ansa, ansb);
//	cout << ansa / p << " " << ansb / p << endl;
//}
//
//int main()
//{
//	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
//	int T = 1;
//	// cin >> T;
//	while (T--)
//	{
//		solve();
//	}
//	return 0;
//}


#include <iostream>
#include <cstring>
using namespace  std;
const int N = 510;
int a[N][N];
int dx[] = { 1, 0, -1, 0 };
int dy[] = { 0, 1, 0, -1 };
void solve()
{
    memset(a, 0, sizeof a);
    int n; cin >> n;
    int k = n * n - 1;
    int p = 0;
    int x = 1, y = 1;
    while (k >= 0)
    {
        a[x][y] = k--;
        int nx = x + dx[p], ny = y + dy[k];
        if (nx < 1 || nx > n || ny < 1 || ny > n || a[nx][ny] != 0) p = (p + 1) % 4;
        x = x + dx[p], y = y + dy[k];
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
}

int main()
{
    int t; cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}
